__init__(
    graph=None,
    ready_op=USE_DEFAULT,
    ready_for_local_init_op=USE_DEFAULT,
    is_chief=True,
    init_op=USE_DEFAULT,
    init_feed_dict=None,
    local_init_op=USE_DEFAULT,
    logdir=None,
    summary_op=USE_DEFAULT,
    saver=USE_DEFAULT,
    global_step=USE_DEFAULT,
    save_summaries_secs=120,
    save_model_secs=600,
    recovery_wait_secs=30,
    stop_grace_secs=120,
    checkpoint_basename='model.ckpt',
    session_manager=None,
    summary_writer=USE_DEFAULT,
    init_fn=None,
    local_init_run_options=None
    )

__init__(
    init_op=None,
    init_feed_dict=None,
    init_fn=None,
    ready_op=None,
    ready_for_local_init_op=None,
    local_init_op=None,
    summary_op=None,
    saver=None,
    copy_from_scaffold=None
)

    tf.train.MonitoredTrainingSession(
    master='',
    is_chief=True,
    checkpoint_dir=None,
    scaffold=None,
    hooks=None,
    chief_only_hooks=None,
    save_checkpoint_secs=USE_DEFAULT,
    save_summaries_steps=USE_DEFAULT(100),
    save_summaries_secs=USE_DEFAULT,
    config=None,
    stop_grace_period_secs=120,
    log_step_count_steps=100,
    max_wait_secs=7200,
    save_checkpoint_steps=USE_DEFAULT,
    summary_dir=None
    )

    def begin(self)

    def after_create_session(self, session, coord)

    def before_run(self, run_context)

    def after_run(self, run_context, run_values)

    def end(self, session)

tf.device(device_name_or_function)

with tf.device("/cpu:0"):
  ...

tf.train.replica_device_setter(cluster=cluster)

from tensorflow.python.client import device_lib

print ("可用计算硬件情况：{}".format(device_lib.list_local_devices()))

>>>可用计算硬件情况：[[name: "/device:CPU:0"
device_type: "CPU"
memory_limit: 268435456
locality {
}
incarnation: 16732882166560050894
, name: "/device:XLA_CPU:0"
device_type: "XLA_CPU"
memory_limit: 17179869184
locality {
}
incarnation: 799772212799803613
physical_device_desc: "device: XLA_CPU device"
, name: "/device:XLA_GPU:0"
device_type: "XLA_GPU"
memory_limit: 17179869184
locality {
}
incarnation: 2714282392667418740
physical_device_desc: "device: XLA_GPU device"
, name: "/device:GPU:0"
device_type: "GPU"
memory_limit: 14892338381
locality {
  bus_id: 1
  links {
  }
}
incarnation: 10914707427568231652
physical_device_desc: "device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5"
]]

tf.train.Example(features:tf.train.Features=xxx)
 |__tf.train.Features(feature:dict=feature_dict)
   |__feature_dict={key:value}
    |__tf.train.Feature(Int64List=int_a)  |__ string
        |__tf.train.BytesList(value=[])

example=tf.train.Example(features:tf.train.Features=xxx)
>>>type(xxx) 
tf.train.Features

tf.train.Features(feature:dict=feature_dict)
>>> type(feature_dict)
dict

feature_dict = {key:value,}
>>>type(key)
string
>>>type(value)
tf.train.Feature  ## 注意没有s

tf.train.Feature(Int64List:tf.train.BytesList=None,FloatList:tf.train.FloatList=None, BytesList:tf.train.Int64List=None)

tf.train.Feature(Int64List=int_a)
tf.train.Feature(FloatList=float_b)
tf.train.Feature(BytesList=bytes_c)

>>>type(int_a)
tf.train.BytesList
>>>type(float_b)
tf.train.FloatList
>>>type(bytes_c)
tf.train.Int64List

tf.train.BytesList(value:list=[])
tf.train.FloatList(value:list=[])
tf.train.Int64List(value:list=[])

tf.train.BytesList(value:list=[b"hello world"])
tf.train.FloatList(value:list=[0.1,0.2])
tf.train.Int64List(value:list=[1,2,3,4])

tf.python_io.TFRecordWriter(path=None)

float_list=tf.train.Int64List(value:list=[1,2,3,4])
feature_value=tf.train.Feature(FloatList=float_list)
feature_dict={"feature_key",feature_value}
features=tf.train.Features(feature:dict=feature_dict)
example=tf.train.Example(features:tf.train.Features=features)

with tf.python_io.TFRecordWriter('customer_1.tfrecord') as writer:
    writer.write(example.SerializeToString())

filenames = ["test.tfrecord", "test2.tfrecord"]
dataset = tf.data.TFRecordDataset(filenames)

dataset=dataset.map(parse_function)
# parse_function 解析函数

def parse_function(example_proto):
    # 只接受一个形参：example_proto，也就是序列化后的样本tf_serialized
    parsed_example = tf.parse_single_example(example_proto, feature_dicts)
    # feature_dicts 解析字典---feature的解析方式
    # feature_dicts={key:value}  key为feature名，value为feature的解析方式

    # 返回所有feature
    return parsed_example

tf.FixedLenFeature(shape:tuple=(1,2), dtype=tf.float32, default_value=None)

tf.VarLenFeature(dtype)
#注：可以不明确指定shape，但得到的tensor是SparseTensor。

# 解码字符
parsed_example['tensor'] = tf.decode_raw(parsed_example['tensor'], tf.uint8)
# 稀疏表示 转为 密集表示
parsed_example['matrix'] = tf.sparse_tensor_to_dense(parsed_example['matrix'])

# 转变matrix形状
parsed_example['matrix'] = tf.reshape(parsed_example['matrix'], parsed_example['matrix_shape'])

# 转变tensor形状
parsed_example['tensor'] = tf.reshape(parsed_example['tensor'], parsed_example['tensor_shape'])

tf.io.parse_example(
    serialized,
    features_spec,
    example_names=None,
    name=None
)
tf.io.parse_example()
tf.parse_example()

# serialized:一个batch的序列化的example 
# features_spec:解析example的规则 
# name：当前操作的名字 
# example_name:当前解析example的proto名称

[op.values() for op in tf.get_default_graph().get_operations()]

graph=tf.get_default_graph()
graph_def=graph.as_graph_def()
type(graph_def)
>>> tensorflow.core.framework.graph_pb2.GraphDef

graph_def
>>>
  node {
    name: "start"
    op: "Const"
    attr {
      key: "dtype"
      value {
        type: DT_INT64
      }
    }
    attr {
      key: "value"
      value {
        tensor {
          dtype: DT_INT64
          tensor_shape {
          }
          int64_val: 0
        }
      }
    }
  }
  library {
    function {
      signature {
        name: "_make_dataset_YADYq1MF2s4"
        output_arg {
          name: "modeldataset"
          type: DT_VARIANT
        }
        description: "Factory function for a dataset."
        is_stateful: true
      }
      node_def {
        name: "RangeDataset/start"
        op: "Const"
        attr {
          key: "dtype"
          value {
            type: DT_INT64
          }
        }
        attr {
          key: "value"
          value {
            tensor {
              dtype: DT_INT64
              tensor_shape {
              }
              int64_val: 0
            }
          }
        }
      }
      ret {
        key: "modeldataset"
        value: "ModelDataset:handle:0"
      }
    }
  }
  versions {
    producer: 27
    min_consumer: 12
  }

saver = tf.train.Saver()

class Saver()
        def __init__(
                var_list=None,
                reshape=False,
                sharded=False,
                max_to_keep=5,
                keep_checkpoint_every_n_hours=10000.0,
                name=None,
                restore_sequentially=False,
                saver_def=None,
                builder=None,
                defer_build=False,
                allow_empty=False,
                write_version=tf.train.SaverDef.V2,
                pad_step_number=False,
                save_relative_paths=False,
                filename=None
        )

1. as_saver_def
         返回一个 SaverDef proto
2. build 
3. export_meta_graph  返回一个MetaGraphDef
4. from_proto   从  saver_def 返回以一个Saver built
5. recover_last_checkpoints 从错误中恢复 saver的初始状态
6. restore  --恢复先前保存的参数变量
7. save -- 保存参数变量

save(
    sess,
    save_path,
    global_step=None,
    latest_filename=None,
    meta_graph_suffix='meta',
    write_meta_graph=True,
    write_state=True,
    strip_default_attrs=False
)

8. set_last_checkpoints --
9. set_last_checkpoints_with_time
10. to_proto。将  Saver 转化成 a SaverDef protocol buffer.

graph=tf.get_default_graph()
graph_def=graph.as_graph_def()

var_list = tf.trainable_variables()
constant_graph = tf.graph_util.convert_variables_to_constants(sess, sess.graph_def, [var_list[i].name[:-2] for i in range(len(var_list))])

        with tf.gfile.FastGFile(pb_path, mode='wb') as f:
                f.write(constant_graph.SerializeToString())

def freeze_graph(input_checkpoint,output_graph):
    '''
    :param input_checkpoint:
    :param output_graph: PB模型保存路径
    :return:
    '''
    # checkpoint = tf.train.get_checkpoint_state(model_folder) #检查目录下ckpt文件状态是否可用
    # input_checkpoint = checkpoint.model_checkpoint_path #得ckpt文件路径

    # 指定输出的节点名称,该节点名称必须是原模型中存在的节点
    output_node_names = "InceptionV3/Logits/SpatialSqueeze"
    saver = tf.train.import_meta_graph(input_checkpoint + '.meta', clear_devices=True)

    with tf.Session() as sess:
        saver.restore(sess, input_checkpoint) #恢复图并得到数据
        output_graph_def = graph_util.convert_variables_to_constants(  # 模型持久化，将变量值固定
            sess=sess,
            input_graph_def=sess.graph_def,# 等于:sess.graph_def
            output_node_names=output_node_names.split(","))# 如果有多个输出节点，以逗号隔开

        with tf.gfile.GFile(output_graph, "wb") as f: #保存模型
            f.write(output_graph_def.SerializeToString()) #序列化输出
        print("%d ops in the final graph." % len(output_graph_def.node)) #得到

构建builder方法如下：
builder = tf.saved_model.builder.SavedModelBuilder("/home/xsr-ai/study/mnist/saved-model")
在训练完后，我们调用如下命令保存模型：

builder.add_meta_graph_and_variables(sess, [tf.saved_model.tag_constants.TRAINING], signature_def_map=None, assets_collection=None)
builder.save()

def add_meta_graph_and_variables(sess,tags,signature_def_map=None,assets_collection=None,legacy_init_op=None,clear_devices=False,main_op=None):


sess：用于执行添加元图和变量功能的会话；
tags：用于保存元图的标签；
signature_def_map：用于保存元图的签名；
assets_collection：使用SavedModel保存的资源集合；
legacy_init_op：在恢复模型操作后，对Op和Ops组的遗留支持；
clear_devices：如果默认图形上的设备信息应该被清除，则应该设置为true；
main_op：在加载图时执行Op或Ops组的操作。请注意，当main_op被指定时，它将在加载恢复op后运行；

    graph_def = tf.GraphDef()

    graph_def.ParseFromString(model_f.read())  ##二进制调用实际上是 ParseFromString

#1. 创建saver

saver=tf.train.Saver()

# 2. 保存参数变量
saver_path = saver.save(sess, save_path="./path/model.ckpt" ,global_step=100)

#1 sess 必须提前加载，同时参数没有初始化
#2 save_path : 返回 str 

    import tensorflow as tf
    tf.contrib.resampler
    saver=tf.train.import_meta_graph(“save/model.ckpt.meta”)

dir_path="./model" # 文件夹地址
model_file=tf.train.latest_checkpoint(dir_path)
saver.restore(sess,model_file)

# sess 必须提前加载，同时参数没有初始化，因为restore 方法本身就是一个初始化的过

# 1. 记录 标量
scalar_summary=tf.summary.scalar(name, tensor, collections=None)
# tensor: 标量 /一个数 A real numeric Tensor containing a single value
type(scalar_summary)
>>> tensorflow.python.framework.ops.Tensor
scalar_summary.dtype
>>> tf.string
scalar_summary.shape
>>>()

# 2. 记录 图片
image_summary=tf.summary.image(name, tensor, max_outputs=3, collections=None, family=None)
# tensor：tensor dtype=`uint8` or `float32`;shape=[batch_size, height, width, channels],其中`channels` 只能是 1, 3, or 4.

audio_summary=tf.summary.audio(name, tensor, collections=None) 
# tensor: A 3-D `float32` `Tensor` of shape `[batch_size, frames, channels]`or a 2-D `float32` `Tensor` of shape `[batch_size, frames]`

text_summary=tf.summary.text(name, tensor, collections=None)
# tensor: a string-type Tensor to summarize.

histogram_summary=tf.summary.histogram(name, values, collections=None, family=None)
#values: 数字类型的Tensor 
# A real numeric `Tensor`. Any shape. Values to use to build the histogram.

distribution_summary=tf.summary.distribution (记录 数据的分布图)

summary_op=tf.summary.merge_all(name=None)

type(summary_op)
>>>tensorflow.python.framework.ops.Tensor

filewriter=tf.summary.FileWriter(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None, session=None)

>>>type(filewriter)
tensorflow.python.summary.writer.writer.FileWriter

init_local_variables=tf.initialize_local_variables()
sess.run (init_local_variables)

# accuracy（相当于calculate_accuracy()）
# update_op（相当于update_running_variables()）
accuracy, update_op =tf.metrics.XXX

tf.metrics.mean_absolute_error(...)

loss=tf.metrics.mean_absolute_error(
    labels,
    predictions,
    weights=None,
    metrics_collections=None,
    updates_collections=None,
    name=None
)

tf.metrics.mean_relative_error(...)

tf.metrics.mean_squared_error(...):

tf.metrics.root_mean_squared_error(...):

tf.metrics.mean_cosine_distance(...):

tf.metrics.accuracy()


real_label=tf.constant([[1],[1],[1]]) # [1] [1] [1]
predict_label=tf.constant([1,1,1]) # [1] [1] [1]

accuracy_op = tf.metrics.accuracy(labels=real_label, predictions=predict_label, name="accuracy_op")
ini_op=[tf.global_variables_initializer(),tf.local_variables_initializer()]
sess=tf.Session()
sess.run(ini_op)
accuracy,update_op=sess.run(accuracy_op)
# (1.0, 1.0)
# accuracy：A Tensor，表示准确性，值total除以count。
# update_op ：适当增加total和count变量并且使其值匹配accuracy的操作。

tf.metrics.precision()

正样本有多少被找出来了（召回了多少）。

tf.metrics.recall()

tf.metrics.auc()
# Computes the approximate AUC via a Riemann sum.

tf.metrics.mean_iou()

import tensorflow as tf

with tf.variable_scope("foo"):
        a = tf.get_variable("bar", [1])
        print a.name    # 输出 foo/bar: 0

with tf.variable_scope("bar"):
        b = tf.get_variable("bar", [1])
        print b.name     # 输出 bar/bar: 0

with tf.name_scope("a"):
        a = tf.Variable([1])
        print a.name     # 输出 a/Va        　　    a = tf.Variable("b", [1]):
　　    print a.name　# 输出 b: 0

with tf.name_scope("b"):
        tf.get_variable("b", [1])        # Error

with tf.name_scope("abc"):
    z = x + y
    z = tf.identity(z, name="z")

with tf.name_scope("abc") as scope:
    # z will get the name "abc". x and y will have names in "abc/..." if they
    # are converted to tensors.
    z = tf.add(x, y, name=scope)

# real_label shape =(N,···)
# predict_label shape =(N,···)
# predict_label.shape==real_label.shape
loss = tf.cast(tf.equal(real_label, predict_label), tf.float32)
# loss shape =(N,1)
cost = tf.reduce_mean(loss)
# cost shape= ()  is a  val 数字

# 注意正确率的定义中 相等以及不等 相反,函数为不正确率 
cost=tf.subtract(tf.constant([1])-accuracy)

# real_label shape =(N,···)
# predict_label shape =(N,···)
# predict_label.shape==real_label.shape
loss=tf.abs(tf.subtract(real_label, predict_label))
# loss shape =(N,···)
cost = tf.reduce_mean(loss,axis=None,keep_dims=False,name=None,reduction_indices=None)
# cost shape= ()  is a  val 数字

loss=tf.losses.absolute_difference(
    labels,
    predictions,
    weights=1.0,
    scope=None,
    loss_collection=tf.GraphKeys.LOSSES,
    reduction=Reduction.SUM_BY_NONZERO_WEIGHTS
)

import numpy as np

# y_true ==labels
# y_pred ==predictions

def logcoss(y_true, y_pred, eps=1e-15):
    # Prepare numpy array data
    y_true = np.array(y_true)
    y_pred = np.array(y_pred) 
    assert (len(y_true) and len(y_true) == len(y_pred))
    # Clip y_pred between eps and 1-eps
    p = np.clip(y_pred, eps, 1-eps)
    loss = np.sum(- y_true * np.log(p) - (1 - y_true) * np.log(1-p))
    cost=loss / len(y_true)
    return cost

log_loss=tf.losses.log_loss(
    labels,
    predictions, 
    weights=1.0,
    epsilon=1e-07, 
    scope=None,
    loss_collection=tf.GraphKeys.LOSSES,
    reduction=Reduction.SUM_BY_NONZERO_WEIGHTS
)
# 注意
If reduction is NONE, this has the same shape as labels; otherwise, it is scalar.


log_loss=tf.losses.log_loss(y_true,y_predict,reduction=None)
type(log_loss)
>>> Tensor 
log_loss_results=sess.run(log_loss)
# log_loss_results.shape =y_true.shape 
log_cost=tf.reduce_sum(log_loss)


log_loss=tf.losses.log_loss(y_true,y_predict)
type(log_loss)
>>> Tensor 
log_loss_results=sess.run(log_loss)
# log_loss_results 标量

type(log_cost)
>>> 标量

# real_label shape =(N,···)
# predict_label shape =(N,···)
# predict_label.shape==real_label.shape
loss=tf.abs(tf.subtract(real_label, predict_label))
# loss shape =(N,···)
cost = tf.reduce_mean(loss,axis=None,keep_dims=False,name=None,reduction_indices=None)
# cost shape= ()  is a  val 数字

mean_squared_error=tf.losses.mean_squared_error(
    labels,
    predictions,
    weights=1.0,
    scope=None,
    loss_collection=tf.GraphKeys.LOSSES,
    reduction=Reduction.SUM_BY_NONZERO_WEIGHTS
)
# mean_squared_error shape =() is a value

# 平方函数实际为 均方差（MSE）
mean_squared_error,update_op=tf.metrics.mean_squared_error(
    labels,
    predictions, #　predictions　为predict＿label
    weights=None,
    metrics_collections=None,
    updates_collections=None,
    name=None
)
# mean_squared_error shape =() is a value

import tensorflow as tf
a = tf.constant([[4.0, 4.0, 4.0], [3.0, 3.0, 3.0], [1.0, 1.0, 1.0]])
b = tf.constant([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [2.0, 2.0, 2.0]])

cost = tf.losses.mean_squared_error(a, b)     
mse_op, mse_update_op= tf.metrics.mean_squared_error(a, b, name="mse")
init_op=tf.initialize_all_variables()
init_op2=tf.initialize_local_variables()
sess.run(init_op2)
sess.run(init_op)

sess.run(cost) #4.6666665
sess.run(mse_update_op) #4.6666665

# real_label.shape ==predict_label.shape==(counts,····)
loss=tf.exp(tf.multiply(-real_label,predict_label))
# loss shape =(counts,····)
cost = tf.reduce_mean(loss,axis=None,keep_dims=False,name=None,reduction_indices=None)
# cost shape= ()  is a  val 数字

loss = tf.maximum(0.0, 1.0-tf.multiply(real_label, predict_label))
# loss shape =real_label.shape==predict_label.shape
cost = tf.reduce_mean(loss,axis=None,keep_dims=False,name=None,reduction_indices=None)
# cost shape= ()  is a  val 数字

hinge_loss=tf.losses.hinge_loss(
    labels,
    logits,
    weights=1.0,
    scope=None,
    loss_collection=tf.GraphKeys.LOSSES,
    reduction=Reduction.SUM_BY_NONZERO_WEIGHTS
)

# huber 损失
def huber(true, pred, delta):
    loss = np.where(np.abs(true-pred) < delta , 0.5*((true-pred)**2), delta*np.abs(true - pred) - 0.5*(delta**2))
    return np.sum(loss)

cross_entropy=tf.nn.sigmoid_cross_entropy_with_logits(
    _sentinel=None,
    labels=None,
    logits=None,
    name=None
)
# labels
# predict_label=sigmoid(logits)
# cross_entropy的shape ：cross_entropy.shape=predict_label.shape=labels.shape

cross_entropy=tf.nn.softmax_cross_entropy_with_logits(
    _sentinel=None,
    labels=None,
    logits=None,
    dim=-1,
    name=None
)

cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(
    _sentinel=None,
    labels=None,
    logits=None,
    name=None
)

# labels.shape==[counts,1]   [1,2,3,4,5]
# logits.shape==[counts,···] 
# cross_entropy.shape====[counts,···]
b = tf.one_hot(label1,CLASS,1,0)

l2_loss=tf.nn.l2_loss(
    t,
    name=None
)

type(l2_loss)
>>>tensor

t: A Tensor. Must be one of the following types: half, bfloat16, float32, float64. Typically 2-D, but may have any dimensions.

graph=tf.Graph()
graph=tf.get_default_graph() 

graph.as_default()
graph.as_graph_def(from_version=None, add_shapes=False)

op=tf.Graph.get_operation_by_name(name)    #根据名称返回操作节点 
tensor=tf.Graph.get_tensor_by_name(name)       #根据名称返回tensor数据 

op_list=tf.Graph.get_operations()  
#返回图中的操作节点列表

layer2 = tf.layers.conv2d(input,filters,kernel_size,kernel_regularizer= tf.contrib.layers.l2_regularizer(scale=0.1)) 

... 
l2_loss = tf.losses.get_regularization_loss() 
loss += l2_loss 

sess = tf.Session()
### 任务完成, 关闭会话.
sess.close()
 session对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 "with" 代码块 来自动完成关闭动作.

tf.constant(
    value,
    dtype=None,
    shape=None,
    name='Const',
    verify_shape=False
)

# tensorflow/python/ops/variables.py
@tf_export("Variable")
class Variable(object):
  def __init__(self,
               initial_value=None,
               trainable=True,
               collections=None,
               validate_shape=True,
               caching_device=None,
               name=None,
               variable_def=None,
               dtype=None,
               expected_shape=None,
               import_scope=None,
               constraint=None):
# initial_value: 初始值，为一个tensor，或者可以被包装为tensor的值
# trainable：是否可以训练，如果为false，则训练时不会改变
# collections：变量要加入哪个集合中，有全局变量集合、本地变量集合、可训练变量集合等。默认加入全局变量集合中
# dtype：变量的类型

# tensorflow/python/framework/ops.py

@tf_export("Tensor")
class Tensor(_TensorLike):
        def __init__(self, op, value_index, dtype)

# -------默认图下
val_a=tf.Variable([1,2,4]) 
# initial_value=[1,2,4] trainable=True,dtype=tf.int 
type(val_a)
>>> tensorflow.python.ops.variables.RefVariable

init_value=val_a.initial_value
type(init_value)
>>>tensorflow.python.framework.ops.Tensor
new_val_a=tf.assign(val_a,[2,2,2])

init_op=tf.global_variables_initializer()

#-------
# 1. 变量必须初始化
sess=tf.Session()
sess.run(val_a) # Error 

sess=tf.Session()
sess.run(init_op)
sess.run(val_a) # [1,2,4]


# 2. 变量数值可变
sess=tf.Session()
sess.run(init_op)
sess.run(val_a) # [1,2,4]
sess.run(new_val_a) # [2,2,2]
sess.run(val_a) # [2,2,2]
sess.run(init_value) # [1,2,4]
sess.run(val_a.initial_value) # [1,2,4]

# 3. 变量类型/shape不能变
# 在Graph中
new_val_a=tf.assign(val_a,[2.0,2.0,2.0]) #Error
new_val_a=tf.assign(val_a,[2,2,2,3]) #Error

# 4 变量内存占用
val_a=tf.Variable([1,2,4]) 
val_b=tf.Variable([1,2,4]*10) 
sys.getsizeof(val_a)
>>>56
sys.getsizeof(val_b)
>>>56

# 5. 张量不需要初始化
sess=tf.Session()
sess.run(init_value) # [1,2,4]

tf.global_variables(scope=None)

@tf_export("global_variables")
def global_variables(scope=None):
  return ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES, scope)
  #可以查询全局变量集合。其op标示为GraphKeys.GLOBAL_VARIABLES

tf.local_variables()

@tf_export("local_variables")
def local_variables(scope=None):
        return ops.get_collection(ops.GraphKeys.LOCAL_VARIABLES, scope)
# 其op标示为GraphKeys.LOCAL_VARIABLES

tf.trainable_variables() 
@tf_export("trainable_variables")
def trainable_variables(scope=None):
  return ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES, scope)
# 其op标示为GraphKeys.TRAINABLE_VARIABLES

tf.model_variables(scope=None)

tf.moving_average_variables(scope=None)

y = tf.Variable([5.3])
with tf.Session() as sess:
    initialization = tf.global_variables_initializer()
    print sess.run(y)

Initializer_instance=···
tf.global_variables_initializer

W = tf.Variable(initial_value=1)
Initializer_instance=tf.initializers.constant(value=0)

# 全1矩阵
W = tf.Variable(initial_value=np.ones(shape=[node_in, node_out]))
Initializer_instance=tf.initializers.ones()

## 0矩阵
W = tf.Variable(initial_value=np.zeros(shape=[node_in, node_out]))
Initializer_instance=tf.initializers.zeros()

## 单位矩阵
W = tf.Variable(initial_value=gain*np.identity(n))
Initializer_instance=tf.initializers.identity(gain=1.0,dtype=tf.float32) # gain: 用于单位矩阵的乘法因子。 




class uniform_unit_scaling：生成张量而不缩放方差的初始化程序.

W = tf.Variable(initial_value=np.random.randn(size=(node_in, node_out)))
Initializer_instance=tf.initializers.random_normal(mean=0.0,stddev=1.0,seed=None,dtype=tf.float32)

W = tf.Variable(initial_value=numpy.random.uniform(low=0.0, high=1.0,size=(node_in, node_out)))

Initializer_instance=tf.initializers.truncated_normal(mean=0.0,stddev=1.0,seed=None,dtype=tf.float32)：生成截断正态分布的初始化程序.

Initializer_instance=tf.initializers.variance_scaling(
    scale=1.0,
    mode='fan_in',
    distribution='untruncated_normal',
    seed=None
)

Initializer_instance=tf.initializers.variance_scaling(
    scale=1.0,
    mode='fan_in',
    distribution='truncated_normal',
    seed=None
)

W = tf.Variable(initial_value=numpy.random.uniform(low=0.0, high=1.0,size=(node_in, node_out)))
Initializer_instance=tf.initializers.random_uniform(minval=0,maxval=1,seed=None,dtype=tf.float32)

Initializer_instance=tf.initializers.variance_scaling(
    scale=1.0,
    mode='fan_in',
    distribution='uniform',
    seed=None
)

Initializer_instance=tf.initializers.glorot_normal(seed=None)
Initializer_instance=tf.initializers.glorot_uniform(seed=None)

tf.keras.initializers.he_uniform(seed=None)

tf.keras.initializers.he_uniform(seed=None)

tf.keras.initializers.lecun_normal(seed=None)

tf.keras.initializers.lecun_uniform(seed=None)

def orthogonal(shape):
    flat_shape = (shape[0], np.prod(shape[1:]))
    a = np.random.normal(0.0, 1.0, flat_shape)
    u, _, v = np.linalg.svd(a, full_matrices=False)
    q = u if u.shape == flat_shape else v
    return q.reshape(shape)
W = tf.Variable(initial_value=orthogonal(shape))

Initializer_instance=tf.initializers.orthogonal(gain=1.0,seed=None)
# gain 放大范围

W = tf.Variable(np.random.randn(node_in, node_out)) * 0.01
......
fc = tf.nn.relu(fc)

W = tf.Variable(np.random.randn(node_in, node_out)) * 0.01

fc = tf.contrib.layers.batch_norm(fc, center=True, scale=True,
                                  is_training=True)
fc = tf.nn.relu(fc)

tf.train.export_meta_graph(
    filename=None,
    meta_info_def=None,
    graph_def=None,
    saver_def=None,
    collection_list=None,
    as_text=False,
    graph=None,
    export_scope=None,
    clear_devices=False,
    clear_extraneous_savers=False,
    strip_default_attrs=False,
    **kwargs
)

saver=tf.train.import_meta_graph(“save/model.ckpt.meta”)
dir_path="./model" # 文件夹地址
model_file=tf.train.latest_checkpoint(dir_path)
saver.restore(sess,model_file)

tf.is_variable_initialized
tf.report_uninitialized_variables
tf.assert_variables_initialized
tf.get_variable
tf.get_local_variable

#只读查询表
tf.initialize_all_tables
tf.tables_initializer

profiler = tf.profiler.Profiler(graph=sess.graph,op_log=None)
# profiler 实例
# op_log: optional. tensorflow::tfprof::OpLogProto proto. Used to define extra op types.

#2.1. 保存运行数据的run_metadata数据结构对象，以记录运行时候的每个OP 的运行时间和内存占用数据
run_metadata = tf.RunMetadata()
type(run_metadata)
>>>tensorflow.core.protobuf.config_pb2.RunMetadata

#2.2. 保存评估器运行参数的run_options数据结构对象 
run_options = tf.RunOptions(trace_level = tf.RunOptions.FULL_TRACE)
type(run_options)
>>>tensorflow.core.protobuf.config_pb2.RunOptions

tf.RunOptions 类
类成员
tf.RunOptions.FULL_TRACE
tf.RunOptions.HARDWARE_TRACE
tf.RunOptions.NO_TRACE
tf.RunOptions.SOFTWARE_TRACE
tf.RunOptions.TraceLevel

op=···
for step in range (total_steps):
        sess.run(op, options=run_options, run_metadata=run_metadata) #@1
        profiler.add_step(step=step, run_meta=run_metadata) #@2
profiler.profile_graph(options=profile_graph_opts_builder.build()) #@3

 with open(current_dir_path+'/profile.pd', 'wb') as f:
        f.write(profiler.serialize_to_string())

Profiler=tf.profiler.Profiler(graph=None,op_log=None)

#graph：tf.Graph。如果为“None”或者未启用“eager执行”，请使用默认图形。
#op_log：可选的。tensorflow :: tfprof :: OpLogProto proto。用于定义额外的op类型。

# 将run_meta和step 添加到Profiler
Profiler.add_step(step,run_meta) # 添加步骤的统计信息。
#step:int->0
#run_meta->run_metadata:

#将ProfileProto序列化为二进制字符串。
Profiler.serialize_to_string()  

# 将run_meta输出到log_dir中
tf.profiler.write_op_log(
    graph,
    log_dir,
    op_log=None,
    run_meta=None,
    add_trace=True
)

Advise=Profiler.advise(options={}) # 自动检测问题并生成报告,返回一个包含所有检查者的报告的Advise原型。

GraphNodeProto=Profiler.profile_graph(options={}) #通过数据流图组织图形节点的统计信息。
GraphNodeProto=Profiler.profile_name_scope(options={})#按名称范围组织图形节点的统计信息。
MultiGraphNodeProto=Profiler.profile_operations(options={})#描述操作类型的统计信息（例如：MatMul，Conv2D）。
MultiGraphNodeProto=Profiler.Profiler.profile_python(options={})  #描述Python代码的统计信息。

type(options)
>>>dict 

# ----------profile
profile=tf.profiler.profile(
    graph=None,
    run_meta=None,
    op_log=None,
    cmd='graph', # 'op'，'scope'，'graph','code'
    options={}
)
type(profile)
>>> tensorflow.core.profiler.tfprof_output_pb2.GraphNodeProto
# 上述等同于--|
Profiler=tf.profiler.Profiler(graph=None,op_log=None)
Profiler.add_step(step,run_meta)
Profiler.profile_graph(options={})

#---------advise
advise=tf.profiler.advise(
    graph=None,
    run_meta=None,
    options=_DEFAULT_ADVISE_OPTIONS
)
type(advise)
>>> tensorflow.core.profiler.tfprof_output_pb2.AdviceProto
# 上述等同于--|
Profiler=tf.profiler.Profiler(graph=None,op_log=None)
Profiler.add_step(step,run_meta)
Profiler.advise(options={})

class AdviceProto：ProtocolMessage

class GraphNodeProto：ProtocolMessage

class MultiGraphNodeProto：ProtocolMessage

class OpLogProto：ProtocolMessage

-max_depth 4       命名空间的深度阈值，超过该阈值的分支不予展示
-min_bytes 0       展示占用内存超过该阈值的OP
-min_micros 10       展示耗时超过该阈值的OP
-min_params  0       展示超过该阈值的参数大小的OP
-min_float_ops 0       展示超过该阈值的浮点计算量的 OP
-min_occurrence  0        展示超过该阈值的出现次数的 OP
-step -1       展示训练时候哪一步的统计情况，默认为最后一步
-order_by micros       统计结果排序字段设定
-account_type_regexes _trainable_variables 
Selectively counting statistics based on node types ，比如这里设定展示可训练变量；account_type_regexes=['.*gpu:0.*'] 设定展示 GPU 运行的变量；
-start_name_regexes .* 
      以下四个选项可以更加灵活的设置展示哪些 OP 
-trim_name_regexes 
-show_name_regexes siamese.*
-hide_name_regexes 
-account_displayed_op_only false
-select micros  选择展示的属性,这里选择查看计算耗时，
-output stdout: 输出方式，这里是标准输出

class ProfileOptionBuilder：
# 用于Profiling API的Option Builder。
# 返回字典

ProfileOptionBuilder=tf.profiler.ProfileOptionBuilder(options={})

# 时间和内存消耗
ProfileOptionBuilder.time_and_memory(
    min_micros=1,
    min_bytes=1,
    min_accelerator_micros=0,
    min_cpu_micros=0,
    min_peak_bytes=0,
    min_residual_bytes=0,
    min_output_bytes=0
)

ProfileOptionBuilder.float_operation()

ProfileOptionBuilder.with_pprof_output(pprof_file="./xxx.pb.gz.") # 生成一个pprof profile gzip file.
ProfileOptionBuilder.with_stdout_output() # c++ std out Print the result to stdout.
ProfileOptionBuilder.with_timeline_output(timeline_file="./xxx.json") #生成一个json 文件
ProfileOptionBuilder.with_file_output(outfile="") #输出一个文件
ProfileOptionBuilder.with_empty_output()#不输出

#定义显示sess.Run() 第70步的统计数据,如果为-1，则使用所#有可用步骤的平均值。
ProfileOptionBuilder.with_step(70)

attributes=[]
ProfileOptionBuilder.select(attributes)

ProfileOptionBuilder.with_min_execution_time(
    min_micros=0,
    min_accelerator_micros=0,
    min_cpu_micros=0
)

ProfileOptionBuilder.with_min_memory(
    min_bytes=0,
    min_peak_bytes=0,
    min_residual_bytes=0,
    min_output_bytes=0
)

ProfileOptionBuilder.with_min_float_operations(min_float_ops)

ProfileOptionBuilder.with_min_parameters(min_params)

#构建profiling选项
profile_opt_dict=ProfileOptionBuilder.build()
type(profile_opt_dict)
>>>dict 

def get_flops(model):
        run_meta = tf.RunMetadata()
        opts = tf.profiler.ProfileOptionBuilder.float_operation()

        # We use the Keras session graph in the call to the profiler.
        flop = tf.profiler.profile(graph=K.get_session().graph,
                                        run_meta=run_meta, cmd='op', options=opts)

        return flop.total_float_ops  # Prints the "flop" of the model.

## 统计参数量
opts = tf.profiler.ProfileOptionBuilder.trainable_variables_parameter()
param_stats = profiler.profile_name_scope(options=opts)
# 总参数量
print('总参数：', param_stats.total_parameters)
# 各scope参数量
for x in param_stats.children:
  print(x.name, 'scope参数：', x.total_parameters)

builder = tf.profiler.ProfileOptionBuilder
opts = builder(builder.time_and_memory())
#opts.with_step(1)
opts.with_timeline_output('timeline.json')
opts = opts.build()

#profiler.profile_name_scope(opts) # 只能保存单step的timeline
profiler.profile_graph(opts) # 保存各个step的timeline

opts = {'AcceleratorUtilizationChecker': {},
        'ExpensiveOperationChecker': {},
        'JobChecker': {},
        'OperationChecker': {}}
profiler.advise(opts)

with tf.contrib.tfprof.ProfileContext('/tmp/train_dir', dump_steps=[10]) as pctx:
  estimator.train() # any thing you want to profile

import tensorflow as tf
from tensorflow.python.client import timeline
from keras import backend as K

run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()

model = ...  # A Keras model

fn = K.function(model.inputs, model.outputs, options=run_options, run_metadata=run_metadata)

for i in range(4):
    x = K.variable(...)
    fn([x])
    tl = timeline.Timeline(run_metadata.step_stats)
    ctf = tl.generate_chrome_trace_format()
    with open('timeline_%d.json' % (i), 'w') as f:
        f.write(ctf)

# /bin/bash/python
import tensorflow as tf


#1. 声明
## 第一个是参数名称，第二个参数是默认值，第三个是参数描述
tf.app.flags.DEFINE_string('str_name', 'default_value',"description1")
tf.app.flags.DEFINE_integer('int_name', 10,"description2")
tf.app.flags.DEFINE_boolean('bool_name', False, "description3")
tf.app.flags.DEFINE_float("float_name",1.111,"description4")

FLAGS = tf.app.flags.FLAGS

#必须带参数，否则：'TypeError: main() takes no arguments (1 given)';   main的参数名随意定义，无要求
def main(_):  
    print(FLAGS.str_name)
    print(FLAGS.int_name)
    print(FLAGS.bool_name)
    print(FLAGS.float_name)
if __name__ == '__main__':
    tf.app.run()  #执行main函数

# shell 
python "xxx.py" --str_name hahaha

y=tf.nn.batch_normalization(
    x,
    mean,
    variance,
    offset,
    scale,
    variance_epsilon,
    name=None
)

tf.gfile.Copy(oldpath, newpath, overwrite=False)

tf.gfile.DeleteRecursively(dirname)
#删除dirname目录下的所有内容。

tf.gfile.Exists(filename)
#判断路径filename是否存在，filename可以是文件路径也可以是文件夹路径。

d=tf.gradients(y_, weight1)